// CVisImageIO.cpp
// Developed by Yang Yu (yuy@janelia.hhmi.org), Oct 1, 2012
//

#include "CVisImageIO.h"

//
//class CVisImageIO
//

CVisImageIO::CVisImageIO():
    m_FileName(NULL),
    m_imagebuff(NULL),
    dimx(1),
    dimy(1),
    dimz(1),
    dimc(1),
    dimt(1),
    dx(1.0),
    dy(1.0),
    dz(1.0),
    dc(1.0),
    dt(1.0)
{
    // supported file suffix
    // .nia .nii .nii.gz
    // .hdr .img .img.gz
    // .tif
}

CVisImageIO::~CVisImageIO()
{
}

// file names
char* CVisImageIO::getFileName()
{
    return this->m_FileName;
}

void CVisImageIO::setFileName(char* FileName)
{
    if(!FileName)
    {
        cout<<"Invalid file name"<<endl;
        return;
    }

    y_new<char, int>(this->m_FileName, strlen(FileName) + 1);
    strcpy(this->m_FileName,FileName);

    return;
}

// dimensions
LONG64 CVisImageIO::getDimx()
{
    return this->dimx;
}

LONG64 CVisImageIO::getDimy()
{
    return this->dimy;
}

LONG64 CVisImageIO::getDimz()
{
    return this->dimz;
}

LONG64 CVisImageIO::getDimc()
{
    return this->dimc;
}

LONG64 CVisImageIO::getDimt()
{
    return this->dimt;
}

void CVisImageIO::setDimx(LONG64 x)
{
    if(x<=0)
    {
        cout << "invalid x dimension"<<endl;
    }
    this->dimx = x;
}

void CVisImageIO::setDimy(LONG64 y)
{
    if(y<=0)
    {
        cout << "invalid y dimension"<<endl;
    }
    this->dimy = y;
}

void CVisImageIO::setDimz(LONG64 z)
{
    if(z<=0)
    {
        cout << "invalid z dimension"<<endl;
    }
    this->dimz = z;
}

void CVisImageIO::setDimc(LONG64 c)
{
    if(c<=0)
    {
        cout << "invalid c dimension"<<endl;
    }
    this->dimc = c;
}

void CVisImageIO::setDimt(LONG64 t)
{
    if(t<=0)
    {
        cout << "invalid t dimension"<<endl;
    }
    this->dimt = t;
}

int CVisImageIO::getDataType()
{
    return this->m_ComponentType;
}

void CVisImageIO::setDataType(unsigned short dt)
{
    this->m_ComponentType = dt;
}

void* CVisImageIO::getData()
{
    return this->m_imagebuff;
}

void CVisImageIO::setFileFormat(FileFormat ff)
{
    this->format = ff;
}

bool CVisImageIO::read(char* filename)
{
    NiftiImageIO niftiIO;
    switch(format)
    {
    case TIFFIMG:
        break;

    case NIFTIIMG:

        if(!niftiIO.canReadFile(filename)) return false;
        if(!niftiIO.read(m_imagebuff)) return false;
            
        setDimx(niftiIO.getDimx());
        setDimy(niftiIO.getDimy());
        setDimz(niftiIO.getDimz());
        setDimc(niftiIO.getDimc());
        setDimt(niftiIO.getDimt());
        
        setDataType(niftiIO.getDataType());

        break;

    default:
        cout<<"unsupported input"<<endl;
    }

    //
    return true;
}

// writing
bool CVisImageIO::write(char* filename)
{
    NiftiImageIO niftiIO;
    switch(format)
    {
        case TIFFIMG:
            break;
            
        case NIFTIIMG:
            
            if(!niftiIO.canWriteFile(filename)) return false;
            niftiIO.write(m_imagebuff, dimx, dimy, dimz, dimc, dimt, m_ComponentType);
            
            break;
            
        default:
            cout<<"unsupported input"<<endl;
    }
    
    //
    return true;
}
